"use strict";
const mvc = require('cosjs.mvc');
const random = mvc.library.require('random');
/**
 * @name unit
 * unit养成
 */
const LINEUP_MAX = 10;
const POS_MAX = 16;
const REST = 1;
const BATTLE = 2;
const DEAD = 3;
const slotItemID = 60800001; //放逐之地槽位道具ID
const deadAreaShopItemID = 1000198 //放逐之地槽位商品ID

/**
 * @name turnUnit
 * @param int id ID
 * 生成单位实例
 */
exports.turnUnit = async function () {
    let id = this.get('id', 'int');
    if (!id) {
        return this.quick_error("M2saghge10", "参数缺失key");
    }
    this.updater.item.sub(id, 1);
    let unitConfig = this.config('unitBase', id);
    if (!unitConfig) {
        return this.quick_error("M2saghge10", "数据表不存在");
    }
    this.updater.add(unitConfig.id, 1);
    await this.updater.save();
    for (let k of this.updater._update_cache) {
        if (k.id == unitConfig.id && k.b == 20) {
            return k._id;
        }
    }
}


/**
 * @name levelUp
 * @param string key 唯一ID
 * @param int expNum 消耗经验道具数量
 * 升级（强化）
 */
exports.levelUp = async function () {
    let key = this.get('key', 'string');
    let expNum = this.get('expNum', 'int');
    if (!key) {
        return this.quick_error("M2saghge10", "参数缺失key");
    }
    if (!expNum || expNum < 0) {
        return this.quick_error("M2saghge10", "参数缺失key");
    }
    this.updater.item.key(key);
    this.updater.role.key('lv');
    this.updater.role.key('syncedUnit.' + key);
    // this.updater.daily.key('growEquipNum');
    await this.updater.data();
    let roleLv = this.updater.role.get('lv');
    let unit = this.updater.item.get(key);
    let syncedUnit = this.updater.role.get('syncedUnit.' + key);

    if (!unit) {
        return this.quick_error("M2saghge20", "角色不存在", key);
    }
    let unitConfig = this.config('unit', unit.id);
    if (!unitConfig) {
        return this.quick_error("M2saghge40", "角色数据不存在", unit.id);
    }
    if (syncedUnit) {
        return this.quick_error('角色被同步中，不可升级', key);
    }
    // let exp = expNum;
    //经验计算
    let expConfig = this.config('unitExp');
    if (!expConfig) {
        return this.quick_error("M2saghge50", "消耗配置不存在");
    }
    let baseExp = unit.exp
    let totalExp = unit.exp + expNum
    let useExpNum = 0;
    let roleConfig = this.config("playerExp", roleLv);
    if (!roleConfig) {
        return this.quick_error("M2saghge50", "到达等级上限");
    }
    let maxLv = roleConfig.maxLevel;
    //判断阶级
    if ((unit.rlv + 1) * 20 <= unit.lv) {
        //需要去升阶
        return this.quick_error("M2HS4", "你需要去升阶");
    }
    let addLv = 0;
    for (let i = unit.lv; i < maxLv; i++) {
        // for (let k of expConfig){
        // if(unit.lv >= maxLv){
        //     //等级不能大于角色等级
        //     break;
        // }
        if ((unit.rlv + 1) * 20 <= unit.lv) {
            break;
        }
        if (expConfig[i].lv == unit.lv) {
            if (totalExp - expConfig[i].exp < 0) {
                useExpNum += totalExp;
                unit.exp = totalExp;
                // if ((unit.rlv+1)*20 == unit.lv){
                //     unit.exp = 0;
                // }else{

                // }
                break;
            } else {
                unit.lv++;
                let recordConfig = this.config("record", "32" + unit.lv)
                if (recordConfig) {
                    this.updater.record.add("32" + unit.lv, 1);
                }
                addLv++;
                totalExp -= expConfig[i].exp
                useExpNum += expConfig[i].exp;
                unit.exp = 0;
            }
        }
    }
    if ((useExpNum - baseExp) <= 0) {
        return this.quick_error("M2saghge50", "啥事没干");
    }
    this.updater.sub(this.config('base', 'unitLevelUpItem').val, useExpNum - baseExp);
    if (!unit.costList[this.config('base', 'unitLevelUpItem').val]) {
        unit.costList[this.config('base', 'unitLevelUpItem').val] = 0;
    }
    unit.costList[this.config('base', 'unitLevelUpItem').val] += useExpNum - baseExp;
    // this.updater.item.set(unit._id, unit);
    this.updater.item.set(unit._id, "exp", unit.exp);
    this.updater.item.set(unit._id, "lv", unit.lv);
    this.updater.item.set(unit._id, "costList", unit.costList);
    // this.updater.role.set('lv',unit.lv)
    //this.updater.record.max(2200, unit.lv);
    this.updater.record.add(13, addLv);
    this.updater.daily.add("record." + "13", addLv);
    // let recordConfig = this.config("record","32"+unit.lv)
    // if(recordConfig){
    //     this.updater.record.add("32"+unit.lv,1);
    // }
    // this.updater.record.add("loginTest",1);
    // let growNum = this.updater.daily.get('growEquipNum') || 0;
    // growNum++;
    // this.updater.daily.set('growEquipNum', growNum);
    return this.updater.save();
}

/**
* @name gradeUp
* @param string key 唯一ID
* @param int rlv 当前阶级
* 升阶段
*/
exports.gradeUp = async function () {
    let key = this.get('key', 'string');
    let lv = this.get('rlv', 'int');
    if (!key) {
        return this.quick_error("M2HS1", "参数缺失");
    }
    this.updater.item.key(key);
    await this.updater.data();
    let ty = this.updater.item.get(key);
    if (!ty) {
        return this.quick_error("M2HS2", "单位不存在");
    }
    let config = this.config("unit", ty["id"]);
    if (!config) {
        return this.quick_error("M2HS3", "单位静态数据不存在", ty["id"]);
    }
    // let HLK = config["unitUpgradeId"]
    let HLK = config["unitUpgradeId"] * 1000 + lv;
    let unitGrade = this.config("unitUpgrade", HLK);
    if (!unitGrade) {
        return this.quick_error("M2HS4", "升阶配置不匹配", HLK);
    }
    await this.updater.data();

    let unit = this.updater.item.get(ty);
    if (!unit) {
        return this.quick_error("M2HS5", "单位不存在", key);
    }
    if (lv != unit.rlv) {
        return this.quick_error("M2HS6", "单位阶级不匹配", unit.rlv);
    }
    for (let d of unitGrade.sub) {
        if (d.id && d.num) {
            this.updater.sub(d.id, d.num);
            if (!unit.costList[d.id]) {
                unit.costList[d.id] = 0;
            }
            unit.costList[d.id] += d.num;
            // break;
        }
    }
    //是不是一阶段
    //装挂件
    // pendantGroup
    if (config.pendantGroup && unit.rlv == 0) {
        let recordConfig = this.config("pendantGroup", config.pendantGroup);
        if (!recordConfig) {
            return this.quick_error("M2HS4", "升阶配置出错", config.pendantGroup);
        }
        let k = random.Relative(recordConfig.Coll, 'val');
        if (k === false) {
            return this.quick_error("M7GHLB123", 'err request', k);
        }
        //随机出个位置
        const pendantMax = this.config('base', 'pendantMax').val;
        let site = Math.roll(0, pendantMax - 1);
        //兼容代码，上线可删
        if (!unit.pendant) {
            unit.pendant = {};
        }
        unit.pendant[site] = recordConfig.Coll[k].pendantId;
    }
    //TODO 暂时没对等级做验证
    unit.rlv += 1;
    let recordConfig = this.config("record", "31" + unit.rlv);
    if (recordConfig) {
        this.updater.record.add("31" + unit.rlv, 1);
    }
    this.updater.item.set(unit._id, "rlv", unit.rlv);
    this.updater.record.add("58", 1);
    //进化逻辑修改，和阶段没啥关系了
    // let evolutionUpConfig = this.config("unitEvolution", unit.id);
    // if (evolutionUpConfig && evolutionUpConfig.upgradeLv == unit.rlv) {
    //     // return this.quick_error("M2HS3","单位静态数据不存在",ty["id"]);
    //     let k = random.Relative(evolutionUpConfig.evolutionGroup, 'probability');
    //     if (k === false || !evolutionUpConfig.evolutionGroup[k]) {
    //         return this.quick_error("M2HS4", "进化配置不匹配");
    //     }
    //     this.updater.item.set(key, "id", evolutionUpConfig.evolutionGroup[k].evolutionId);
    // }
    // if(ty.rlv != config.upgradeLv){
    //     return this.quick_error("M2HS4","进化配置不匹配",ty["id"],ty.rlv);
    // }
    this.updater.item.set(unit._id, "costList", unit.costList);
    this.updater.item.set(unit._id, "pendant", unit.pendant);
    return this.updater.save();
}


/**
* @name starUp
* @param string key 唯一ID
* @param int slv 当前星级
* @param string sub 消耗列表，用,切割
* @param int num 消耗多少幼崽
* 升星
*/
exports.starUp = async function () {
    let key = this.get('key', 'string');
    let slv = this.get('slv', 'int');
    let num = this.get('num', 'int');

    const sub = this.get('sub', 'string').trim();
    if (!key) {
        return this.quick_error("M2HS1", "参数缺失");
    }
    if (!sub && !num) {
        return this.quick_error('M2saghge140', '必须有消耗品');
    }
    let subNum = 0;

    let arrSub = sub.split(",");
    for (let s of arrSub) {
        if (!s && !num) {
            return this.quick_error('M2saghge150', '消耗品不能为空');
        }
        this.updater.item.key(s);
        subNum++;
    }
    if (sub == '') {
        subNum = 0;
    }
    subNum += num;
    this.updater.item.key(key);

    // this.updater.role.key('battleArea');//战斗区
    // this.updater.role.key('restArea');//休息区
    this.updater.role.key('deadArea');//死亡区
    this.updater.role.key('helpUnit');//助战
    // this.updater.role.key('teamList');//客户端维护吧
    await this.updater.data();
    // let restAreaList = this.updater.role.get('restArea') || {};
    // let deadAreaList = this.updater.role.get('deadArea')||{};
    // let battleAreaList = this.updater.role.get('battleArea') || {};
    // let teamList = this.updater.role.get('teamList')||[];
    // let helpID = this.updater.role.get('helpUnit')||"";
    // let restAreaFlag = 0;
    // let deadAreaFlag = 0;
    // let battleAreaFlag = 0;


    // this.updater.role.key('deadArea');
    // await this.updater.data();
    let deadAreaList = this.updater.role.get('deadArea') || {};
    let unit = this.updater.item.get(key);
    // console.log("id:", key);
    // console.log("unit:", unit);

    if (!unit) {
        return this.quick_error("M2saghge160", "单位不存在", key);
    }
    if (slv != unit.slv) {
        return this.quick_error("M2saghge170", "目标等级不匹配", unit.slv, slv,);
    }

    let unitConfig = this.config('unit', unit.id);
    let configId = unitConfig.rare * 1000 + slv;
    let refineConfig = this.config('unitStarup', configId);
    if (!refineConfig) {
        return this.quick_error("M2saghge171", "配置不存在", configId);
    }
    if (refineConfig.num != subNum) {
        return this.quick_error("M2saghge180", "消耗数量不对", subNum, refineConfig.num);
    }
    //开始消耗
    let set = {}
    let deadAreaFlag = 0;
    //TODO:要走分解的所有逻辑
    //TODO: 要验证lock
    if (sub != '') {
        for (let s of arrSub) {
            let ss = this.updater.item.get(s);
            if (!ss) {
                return this.quick_error('M2saghge190', '消耗的装备不存在', ss);
            }
            if (set[s]) {
                return this.quick_error('M2saghge191', '有重复的材料', s);
            }
            set[s] = 1;
            //TODO 判定是否在使用中
            let sConfig = this.config('unitStarUpMaterial', ss.id);
            if (!sConfig) {
                if (ss.id != unit.id) {
                    return this.quick_error("M2saghge200", "材料装备配置不存在", s);
                }
            }
            // for (let key in restAreaList) {
            //     if (s == key) {
            //         delete restAreaList[key];
            //         restAreaFlag++;
            //     }
            // }
            for (let key in deadAreaList) {
                if (s == key) {
                    delete deadAreaList[key];
                    deadAreaFlag++;
                }
            }
            // for (let key in battleAreaList) {
            //     if (s == key) {
            //         delete battleAreaList[key];
            //         battleAreaFlag++;
            //     }
            // }
            this.updater.item.del(s);
        }
    }

    // if(deadAreaFlag !=0){
    //     this.updater.role.set('deadArea',deadAreaList);
    // }  
    // if (restAreaFlag != 0) {
    //     this.updater.role.set('restArea', restAreaList);
    // }
    if (deadAreaFlag != 0) {
        this.updater.role.set('deadArea', deadAreaList);
    }
    // if (battleAreaFlag != 0) {
    //     this.updater.role.set('battleArea', battleAreaList);
    // }
    unit.slv++;
    if (num) {
        this.updater.item.sub(unitConfig.babyId, num);
    }
    // console.log("unit_last:", unit)
    this.updater.item.set(unit._id, "slv", unit.slv);
    // this.updater.record.add(2300, 1);
    return this.updater.save();
}


/**
* @name evolutionUp
* @param string key 唯一ID
* 单位进化
*/
exports.evolutionUp = async function () {
    let key = this.get('key', 'string');
    // let lv = this.get('rlv', 'int');
    if (!key) {
        return this.quick_error("M2HS1", "参数缺失");
    }
    this.updater.item.key(key);
    await this.updater.data();
    let ty = this.updater.item.get(key);
    if (!ty) {
        return this.quick_error("M2HS2", "单位不存在");
    }
    let config = this.config("unitEvolution", ty["id"]);
    if (!config) {
        return this.quick_error("M2HS3", "单位静态数据不存在", ty["id"]);
    }
    // if(ty.rlv != config.upgradeLv){
    //     return this.quick_error("M2HS4","进化配置不匹配",ty["id"],ty.rlv);
    // }

    //判断config.itemNeed是否存在
    if (!config.itemNeed) {
        return this.quick_error("M2HS4", "进化配置不匹配");
    }
    let baseConfig = this.config("unit", ty["id"]);
    if (!config) {
        return this.quick_error("M2HS3", "单位静态数据不存在", ty["id"]);
    }
    let baseLv = baseConfig.rare;
    this.updater.sub(config.itemNeed, 1);

    let k = random.Relative(config.evolutionGroup, 'probability');
    if (k === false || !config.evolutionGroup[k]) {
        return this.quick_error("M2HS4", "进化配置不匹配");
    }

    //进化后单位对应之前单位已升级过技能的ID名修改
    let skillList = ty.skillList || {};
    if (Object.keys(skillList).length) {
        let evolvedUnitId = config.evolutionGroup[k].evolutionId;
        let skillConfig = this.config('skillSets');
        if (!skillConfig) {
            return this.quick_error('角色技能配置不存在', ty["id"]);
        }
        let oldSkillConfig = skillConfig[ty["id"]].skills;
        let evolvedUnitConfig = skillConfig[evolvedUnitId].skills;
        for (let i = 0; i < oldSkillConfig.length; i++) {
            if (skillList[oldSkillConfig[i]]) {
                skillList[evolvedUnitConfig[i]] = skillList[oldSkillConfig[i]];
                delete skillList[oldSkillConfig[i]];
            }
        }
        this.updater.item.set(key, "skillList", skillList);

    }
    //返还进化前单位的技能升级材料
    let unitConfig = this.config('unit', ty.id);
    let returnNum = 0;
    for (let slv = baseLv; slv < ty.slv; slv++) {
        let configId = unitConfig.rare * 1000 + slv;
        let refineConfig = this.config('unitStarup', configId);
        if (!refineConfig) {
            break;
        }
        returnNum += refineConfig.num;
    }
    // returnNum -= 1;
    //分解给东西
    //给box
    let sConfig = this.config('decompose', unitConfig.rare);
    if (!sConfig) {
        return this.quick_error("M2saghge200", "材料装备配置不存在", ss.id);
    }
    this.updater.item.add(sConfig.decomposeReceive[unitConfig.element - 1], returnNum);
    this.updater.item.set(key, "id", config.evolutionGroup[k].evolutionId);
    //星级不继承
    let newUnitConfig = this.config('unit', config.evolutionGroup[k].evolutionId);
    this.updater.item.set(key, "slv", newUnitConfig.rare);
    switch (config.evolutionGroup[k].evolutionId) {
        case 20002023:
            this.updater.record.max(6601, 1);
            break;
        case 20002022:
            this.updater.record.max(6602, 1);
            break;
        case 20002021:
            this.updater.record.max(6603, 1);
            break;
        default:
    }
    let collectConfig = mvc.config('unit', config.evolutionGroup[k].evolutionId);
    if (!collectConfig) {
        return debug('config not exist', 'unit', id);
    }
    if (collectConfig['unityCollect'] != 0 && collectConfig['unityCollect'] != undefined) {
        this.updater.collect.max(config.evolutionGroup[k].evolutionId, 1, 1);
    }
    return this.updater.save();
}



/**
* @name skillUp
* @param string key 唯一ID
* @param int skillID 技能
* 技能升级
*/
exports.skillUp = async function () {
    let key = this.get('key', 'string');
    let skillID = this.get('skillID', 'int');
    if (!key || !skillID) {
        return this.quick_error("M2HS1", "参数缺失");
    }
    this.updater.item.key(key);
    this.updater.role.key("syncedUnit." + key);
    await this.updater.data();
    let ty = this.updater.item.get(key);
    let syncedUnit = this.updater.role.key('syncedUnit.' + key);
    if (syncedUnit) {
        return this.quick_error('角色被同步中，不可以升级技能');
    }
    if (!ty) {
        return this.quick_error("M2HS2", "单位不存在");
    }
    let config = this.config("unit", ty["id"]);
    if (!config) {
        return this.quick_error("M2HS3", "单位静态数据不存在", ty["id"]);
    }
    let unit = this.updater.item.get(ty);
    if (!unit) {
        return this.quick_error("M2HS5", "单位不存在", key);
    }
    await this.updater.data();
    // let HLK = config["unitUpgradeId"]
    let lv = unit.skillList[skillID] || 1;
    let HLK = config["skillUpgradeId"] * 1000 + lv;
    let unitGrade = this.config("skillUpgrade", HLK);
    if (!unitGrade) {
        return this.quick_error("M2HS4", "升阶配置不匹配", HLK);
    }
    for (let d of unitGrade.sub) {
        if (d.id && d.num) {
            this.updater.sub(d.id, d.num);
            if (!unit.costList[d.id]) {
                unit.costList[d.id] = 0;
            }
            unit.costList[d.id] += d.num;
        }
    }



    // if(lv != unit.rlv){
    //     return this.quick_error("M2HS6","单位阶级不匹配",unit.rlv);
    // }
    //TODO 暂时没对等级做验证
    unit.skillList[skillID] = lv + 1;
    // if(unit.skillList[skillID]){
    //     unit.skillList.defineHandlePrototype(skillID,lv+1);
    // }else{
    //     unit.skillList[skillID]=lv+1;
    // }
    this.updater.item.set(unit._id, "skillList", unit.skillList);
    this.updater.item.set(unit._id, "costList", unit.costList);
    this.updater.record.add(14, 1);
    this.updater.daily.add("record." + "14", 1);
    return this.updater.save();
}



//  const REST = 1;
//  const BATTLE = 2;
//  const DEAD = 3;

/**
* @name setRestArea
* @param string data  休息区数据
* 更新休息区
*/
exports.setRestArea = async function () {
    let unitData = this.get('data', 'string');
    this.updater.role.set('restArea', unitData);
    return this.updater.save();

    if (!unitData) {
        return this.quick_error('M2saghge140', ' 参数错误');
    }
    if (unitData.id != "") {
        this.updater.item.key(unitData.id);
    }
    this.updater.role.key('restArea');
    await this.updater.data();
    let restAreaList = this.updater.role.get('restArea');
    if (unitData.id != "") {
        let unit = this.updater.item.get(unitData.id);
        if (!unit) {
            //去判断在不在表里
            let babyConfig = this.config('unitBase', unitData.id);
            if (!babyConfig) {
                return this.quick_error("M2saghge40", "角色数据不存在", unitData.id);
            }
            //是放幼体
            restAreaList[unitData.siteID] = unitData.id;
            // return this.quick_error("M2saghge20", " 角色不存在", unitData.id);
        }
        restAreaList[unitData.siteID] = unitData.id;
    } else {
        delete restAreaList[unitData.siteID];
    }
    this.updater.role.set('restArea', restAreaList);
    return this.updater.save();
}



/**
* @name setBattleArea
* @param string data 
* 更新战斗区
*/
exports.setBattleArea = async function () {
    let data = this.get('data', 'string');

    this.updater.role.set('battleArea', data)
    return this.updater.save();


    let flag = this.get('flag', 'int');
    if (!unitID) {
        return this.quick_error('M2saghge140', ' 参数错误');
    }
    //去判断在不在表里
    let babyConfig = this.config('unitBase', unitID);
    if (!babyConfig) {
        this.updater.item.key(unitID);
        // return this.quick_error("M2saghge40", "角色数据不存在", unitID);
    }

    this.updater.role.key('battleArea');
    await this.updater.data();
    let battleAreaList = this.updater.role.get('battleArea');
    // let babyConfig = this.config('unitBase', unitID);
    if (!babyConfig) {
        let unit = this.updater.item.get(unitID);
        if (!unit) {
            return this.quick_error("M2saghge40", "角色数据不存在", unitID);
        }
        //成熟体
        if (!flag) {
            delete battleAreaList[unitID];
        } else {
            battleAreaList[unitID] = 1
        }
    } else {
        //幼体
        if (!flag) {
            if (battleAreaList[unitID] == 1) {
                delete battleAreaList[unitID];
            } else {
                battleAreaList[unitID]--;
            }
            // return this.quick_error('M2saghge140', '该位置不可使用',restAreaList[unitID]);
        } else {
            battleAreaList[unitID]++;
        }

    }


    let num = 0;
    for (let key in battleAreaList) {
        num += battleAreaList[key];
    }
    // let battleMaxMember = parseInt(this.config("base","battleMaxMember"));
    if (num > this.config('base', 'battleMaxMember').val) {
        return this.quick_error("M2saghge20", "超出战斗人数上限", battleAreaList.length);
    }
    // if(unit.use!=''){
    //     return this.quick_error('M2saghge140', '蛋已经在其他地方孵化中');
    // }
    // 设置孵化器

    // restAreaList[unitData.siteID].beginTime = Date.now();
    // this.updater.item.set(unitData.id,'use',eggData.siteID)
    this.updater.role.set('battleArea', battleAreaList)
    // this.updater.item.set(unit._id,'arena', BATTLE);
    return this.updater.save();
}


/**
 * @name setDeadList
 * @param string ID unit唯一id
 * 设置死亡名单
 */
exports.setDeadList = async function () {
    let unitID = this.get('ID', 'string');
    if (!unitID) {
        return this.quick_error('M2saghge140', '参数错误');
    }
    this.updater.item.key(unitID);
    this.updater.role.key('deadList');
    this.updater.role.key('battleArea');
    this.updater.role.key('deadArea');
    await this.updater.data();
    let deadList = this.updater.role.get('deadList') || {}; //死亡名单
    // let battleAreaList = this.updater.role.get('battleArea') || {}; //战斗区
    let deadAreaList = this.updater.role.get('deadArea') || {}; //放逐之地
    let unit = this.updater.item.get(unitID);
    if (!unit) {
        return this.quick_error('M2saghge20', '单位不存在', unit);
    }
    if (deadList[unitID] != undefined) {
        return this.quick_error('死亡名单已有该单位', unitID);
    }

    let addTime = 0;
    // //客户端维护战斗区后不需要了
    // //从战斗区放入死亡名单
    // if (battleAreaList[unitID]) {
    //     delete battleAreaList[unitID];
    //     this.updater.role.set('battleArea', battleAreaList);
    // }
    //从放逐之地放入死亡名单
    if (deadAreaList[unitID]) {
        addTime = Date.now() - unit.deadTime + deadAreaList[unitID].addTime;
        delete deadAreaList[unitID];
        this.updater.role.set('deadArea', deadAreaList);
        this.updater.item.set(unitID, 'deadTime', '0');
    }
    deadList[unitID] = { "addTime": addTime };
    this.updater.role.set('deadList', deadList);
    return this.updater.save();
}

/**
 * @name setDeadArea
 * @param string ID 唯一id
 * 设置放逐之地
 */
exports.setDeadArea = async function () {
    let unitID = this.get('ID', 'string');
    if (!unitID) {
        return this.quick_error('M2saghge140', '参数错误', unitID);
    }

    this.updater.item.key(unitID);
    this.updater.role.key('deadArea');
    this.updater.role.key('deadAreaContainer');
    this.updater.role.key('deadList');
    await this.updater.data();
    let unit = this.updater.item.get(unitID);
    if (!unit) {
        return this.quick_error('M2saghge20', 'unit不存在', unitID);
    }
    let deadList = this.updater.role.get('deadList') || {};
    let deadAreaContainer = this.updater.role.get('deadAreaContainer');
    let deadAreaList = this.updater.role.get('deadArea') || {};

    //判断是否符合将unit放置于放逐之地
    if (deadList[unitID] == undefined) {
        return this.quick_error('unit不在死亡名单上', unitID);
    }
    if (deadAreaList[unitID]) {
        return this.quick_error('unit已在放逐之地', unitID);
    }
    if (Object.keys(deadAreaList).length >= deadAreaContainer) {
        return this.quick_error('放逐之地已容纳不下更多的unit! 请先扩容', unitID);
    }

    //符合放置条件，对应列表增加删除
    if (deadList[unitID].addTime) {
        deadAreaList[unitID] = { "addTime": deadList[unitID].addTime };
    } else deadAreaList[unitID] = { "addTime": 0 };

    delete deadList[unitID];
    unit.deadTime = Date.now();

    this.updater.role.set('deadArea', deadAreaList);
    this.updater.role.set('deadList', deadList);
    this.updater.item.set(unitID, 'deadTime', unit.deadTime);
    return this.updater.save();

}

/**
* @name revive
* @param string ID  
* 复活人物
*/
exports.revive = async function () {
    let unitID = this.get('ID', 'string');
    if (!unitID) {
        return this.quick_error('M2saghge140', ' 参数错误');
    }

    let unitIDArr = unitID.split(',');
    for (let i = 0; i < unitIDArr.length; i++) {
        //获取egg信息
        //获取孵化器信息
        this.updater.item.key(unitIDArr[i]);
    }
    this.updater.role.key('deadArea');
    await this.updater.data();
    let restAreaList = this.updater.role.get('deadArea');

    for (let i = 0; i < unitIDArr.length; i++) {
        let unit = this.updater.item.get(unitIDArr[i]);
        if (!unit) {
            return this.quick_error("M2saghge20", " 没这人吧", unitIDArr[i]);
        }
        if (restAreaList[unitIDArr[i]] == undefined) {
            return this.quick_error('M2saghge140', '这人没死吧', restAreaList[unitIDArr[i]]);
        }
        // console.log("deadTime:--------------------------",unit.deadTime)
        unit.deadTime -= restAreaList[unitIDArr[i]].addTime
        // console.log("deadTime:--------------------------",unit.deadTime,restAreaList[unitID].addTime)
        // if(unit.use!=''){
        //     return this.quick_error('M2saghge140', '蛋已经在其他地方孵化中');
        // }
        // 设置孵化器
        let config = this.config("unit", unit["id"]);
        if (!config) {
            return this.quick_error("M2HS3", "单位静态数据不存在", unit["id"]);
        }
        if ((Date.now() - unit.deadTime) / 1000 < config.resurrectionTime) {
            return this.quick_error("M2HS3", "时间不够", unit["id"], (Date.now() - unit.deadTime) / 1000, config.resurrectionTime);
        }
        unit.deadTime = "0";
        delete restAreaList[unitIDArr[i]];
        // restAreaList[unitID] = {"unitID":unitID,"addTime":0}
        // restAreaList[unitID].addTime = 0
        // restAreaList[unitData.siteID].beginTime = Date.now();
        this.updater.item.set(unit._id, 'deadTime', unit.deadTime)
    }

    this.updater.role.set('deadArea', restAreaList)
    return this.updater.save();
    // return ;
}


/**
 * @name boostUnit
 * @param string unitID
 * @param int itemID
 * @param int num
 * 复活加速
 */
exports.boostUnit = async function () {
    let eggID = this.get('unitID', 'string');
    if (!eggID) {
        return this.quick_error('M2saghge140', ' 参数错误');
    }
    let itemID = this.get('itemID', 'string');
    if (itemID <= 0) {
        return this.quick_error('M2saghge140', ' 参数错误');
    }
    let num = this.get('num', 'int');
    if (num <= 0) {
        return this.quick_error('M2saghge140', ' 参数错误');
    }
    let costList = this.config('base', 'speedUpCostItem').strVal.split(',');
    let subTime = 0;
    for (let i = 0; i < costList.length; i++) {
        let arr = costList[i].split(':');
        if (parseInt(arr[0], 10) == itemID) {
            subTime = parseInt(arr[1], 10);
        }
    }
    if (subTime == 0) {
        return this.quick_error("M2saghge40", "消耗配置不存在", siteID);
    }
    //获取egg信息
    //获取孵化器信息
    this.updater.item.key(eggID);
    this.updater.role.key('deadArea');
    await this.updater.data();
    let egg = this.updater.item.get(eggID);
    if (!egg) {
        return this.quick_error("M2saghge20", " 蛋不存在", eggID);
    }
    if (egg.deadTime == '0') {
        return this.quick_error('M2saghge140', '蛋不在被孵化中');
    }
    let restAreaList = this.updater.role.get('deadArea');

    // let oldTime = parseInt(egg.sumTime)||0;
    // egg.sumTime = oldTime+num*subTime*1000

    // restAreaList[unitID] = {"unitID":unitID,"addTime":0}
    restAreaList[eggID].addTime += num * subTime * 1000
    this.updater.sub(parseInt(itemID), parseInt(num));
    // this.updater.item.set(eggID,'sumTime',egg.sumTime);
    this.updater.role.set('deadArea', restAreaList)
    return this.updater.save();
}



/**
 * @name refine
 * @param string sub 芯片ID串,以","分割
 * @param json unitBaby 幼体ID
 * 分解
 */
exports.refine = async function () {
    //TODO：上锁逻辑需要补全
    const sub = this.get('sub', 'string').trim();
    // const id = this.get('id', 'int');
    // const num = this.get('num', 'int');
    const unitBaby = this.get('unitBaby', 'json');
    let unitNum = 0;
    let subNum = 0;
    for (let k in unitBaby) {
        if (unitBaby[k]) {
            unitNum += unitBaby[k];
        }
    }
    if (!sub && !unitNum) {
        return this.quick_error('M2saghge140', '必须有消耗品');
    }
    let arrSub = sub.split(",");

    if (sub != '') {
        for (let s of arrSub) {
            if (!s) {
                return this.quick_error('M2saghge150', '消耗品不能为空');
            }
            this.updater.item.key(s);
            subNum++;
        }
    }
    if (sub == '') {
        subNum = 0;
    }


    // subNum += num;
    let syncBuildId = this.config('base', 'collectBuild_LevelConnect').val;
    if (!syncBuildId) {
        return this.quick_error('同步器建筑未配置');
    }
    this.updater.role.key('battleArea');//战斗区
    this.updater.role.key('restArea');//休息区
    this.updater.role.key('deadArea');//死亡区
    this.updater.role.key('helpUnit');//助战
    this.updater.role.key('buildingsInfo.' + syncBuildId + '.slot');//同步器内的unit
    // this.updater.role.key('teamList');//客户端维护吧
    await this.updater.data();
    // let restAreaList = this.updater.role.get('restArea') || {};
    let deadAreaList = this.updater.role.get('deadArea') || {};
    // let battleAreaList = this.updater.role.get('battleArea') || {};
    // let teamList = this.updater.role.get('teamList')||[];
    let helpID = this.updater.role.get('helpUnit') || "";
    let syncBuildInfo = this.updater.role.get('buildingsInfo.' + syncBuildId + '.slot');

    // let restAreaFlag = 0;
    let deadAreaFlag = 0;
    // let battleAreaFlag = 0;
    // let teamFlag = 0;
    let set = {}
    if (sub != '') {
        for (let s of arrSub) {
            if (syncBuildInfo) {
                for (let item in syncBuildInfo) {
                    if (syncBuildInfo[item] == {}) {
                        continue;
                    }
                    if (syncBuildInfo[item].providerId == s || syncBuildInfo[item].beneficiaryId == s) {
                        return this.quick_error('角色在同步器内，不能进行分解', s);
                    }
                }
            }

            let ss = this.updater.item.get(s);
            if (!ss) {
                return this.quick_error('M2saghge190', '消耗的装备不存在', s);
            }
            if (set[s]) {
                return this.quick_error('M2saghge191', '有重复的材料', s);
            }
            set[s] = 1;
            let unitConfig = this.config('unit', ss.id);
            if (!unitConfig) {
                return this.quick_error("M2saghge40", "角色数据不存在", ss.id);
            }
            //给box
            let sConfig = this.config('decompose', unitConfig.rare);
            if (!sConfig) {
                return this.quick_error("M2saghge200", "材料装备配置不存在", ss.id);
            }
            this.updater.item.group(sConfig.decomposeReceive[unitConfig.element - 1]);
            //返回养成材料
            for (let key in ss.costList) {
                this.updater.item.add(parseInt(key), ss.costList[key]);
            }
            this.updater.item.del(s);
            if (helpID == s) {
                this.updater.role.set('helpUnit', "");
            }
            //芯片
            for (let key in ss.chipList) {
                if (ss.chipList != "") {
                    this.updater.item.set(ss.chipList[key], "use", "");
                }
            }
            // //判断是否在否在休息区
            // for (let key in restAreaList) {
            //     if (s == key) {
            //         delete restAreaList[key];
            //         restAreaFlag++;
            //     }
            // }
            for (let key in deadAreaList) {
                if (s == key) {
                    delete deadAreaList[key];
                    deadAreaFlag++;
                }
            }
            // for (let key in battleAreaList) {
            //     if (s == key) {
            //         delete battleAreaList[key];
            //         battleAreaFlag++;
            //     }
            // }
        }
    }

    // if (restAreaFlag != 0) {
    //     this.updater.role.set('restArea', restAreaList);
    // }
    if (deadAreaFlag != 0) {
        this.updater.role.set('deadArea', deadAreaList);
    }
    // if (battleAreaFlag != 0) {
    //     this.updater.role.set('battleArea', battleAreaList);
    // }

    for (let id in unitBaby) {
        let num = unitBaby[id];
        {
            let babyConfig = this.config('unitBase', id);
            if (!babyConfig) {
                return this.quick_error("M2saghge40", "角色数据不存在", id);
            }
            let unitConfig = this.config('unit', babyConfig.id);
            if (!unitConfig) {
                return this.quick_error("M2saghge40", "角色数据不存在", id);
            }
            //给box
            let sConfig = this.config('decompose', unitConfig.rare);
            if (!sConfig) {
                return this.quick_error("M2saghge200", "材料装备配置不存在", id);
            }
            // for (let i = 0; i < num; i++) {
            this.updater.item.group(sConfig.decomposeReceive[unitConfig.element - 1], num);
            // }
            // //返回养成材料
            // for (let key in ss.costList) {
            //     this.updater.item.add(parseInt(key), ss.costList[key]);
            // }
        }
        if (num) {
            this.updater.item.sub(parseInt(id), num);
        }
    }

    this.updater.record.add(49, subNum + unitNum);
    return this.updater.save();

}


/**
* @name loveUnit
* @param string key 唯一ID
* @param int love 0是不爱1是爱
* 设置单位喜欢状态
*/
exports.loveUnit = async function () {
    let key = this.get('key', 'string');
    // let lv = this.get('rlv', 'int');
    if (!key) {
        return this.quick_error("M2HS1", "参数缺失");
    }
    let love = this.get('love', 'int') || 0;
    if (love != 0) {
        love = 1;
    }
    this.updater.item.key(key);
    await this.updater.data();
    let ty = this.updater.item.get(key);
    if (!ty) {
        return this.quick_error("M2HS2", "单位不存在");
    }
    this.updater.item.set(key, "love", love);
    return this.updater.save();
}

